package com.eduagent.xwqeduagent.app.agent;

import com.eduagent.xwqeduagent.constant.FileConstant;
import com.eduagent.xwqeduagent.model.vo.WebScrapingResultVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

@Slf4j
@Component
public class WebScraping {

    /**
     * 网页抓取
     * @param content 抓取内容
     * @param userId 用户ID
     * @param sessionId 会话ID
     * @return 网页抓取结果
     */
    public WebScrapingResultVO performWebScraping(String content, String userId, String sessionId) {
        log.info("开始网页抓取，内容：{}，用户ID：{}", content, userId);

        // Coze API配置
        String cozeApiUrl = "https://api.coze.cn/v3/chat";
        String botId = "7507628622014971956"; // 请替换为实际的网页抓取botId
        String apiKey = "pat_qm2xo8JAVOw7DGJcgmbpMTENCEst9IBcMt2xxRKig1RJLH9QBHDeEq6jgb2rKCxj"; // 请替换为实际的API密钥

        try {
            // 构建请求体
            cn.hutool.json.JSONObject requestBody = new cn.hutool.json.JSONObject();
            requestBody.set("bot_id", botId);
            requestBody.set("user_id", userId);
            requestBody.set("stream", false);
            requestBody.set("auto_save_history", true);

            // 构建消息内容
            cn.hutool.json.JSONArray additionalMessages = new cn.hutool.json.JSONArray();
            cn.hutool.json.JSONObject message = new cn.hutool.json.JSONObject();
            message.set("role", "user");
            message.set("content", "请帮我抓取以下网页内容：" + content);
            message.set("content_type", "text");
            additionalMessages.add(message);

            requestBody.set("additional_messages", additionalMessages);

            // 设置请求头
            HashMap<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + apiKey);
            headers.put("Content-Type", "application/json");

            // 发送HTTP请求
            String result = cn.hutool.http.HttpUtil.createPost(cozeApiUrl)
                    .headerMap(headers, true)
                    .body(requestBody.toString())
                    .execute()
                    .body();

            log.info("网页抓取API响应：{}", result);

            // 解析响应
            cn.hutool.json.JSONObject responseJson = new cn.hutool.json.JSONObject(result);

            // 检查状态
            if (responseJson.containsKey("data") && responseJson.getJSONObject("data").containsKey("status")) {
                String status = responseJson.getJSONObject("data").getStr("status");
                String conversationId = responseJson.getJSONObject("data").getStr("conversation_id");
                String chatId = responseJson.getJSONObject("data").getStr("id");

                if ("in_progress".equals(status)) {
                    // 如果状态是"in_progress"，需要轮询获取结果
                    return pollForWebScrapingResult(conversationId, botId, apiKey, chatId, content, sessionId);
                } else if ("completed".equals(status)) {
                    // 如果已完成，直接处理结果
                    return processWebScrapingResult(responseJson, content, sessionId);
                } else {
                    // 其他状态处理
                    log.warn("网页抓取状态未知：{}", status);
                    return WebScrapingResultVO.builder()
                            .status("error")
                            .message("网页抓取状态未知: " + status)
                            .targetUrl(content)
                            .sessionId(sessionId)
                            .scrapeTime(new Date())
                            .build();
                }
            } else {
                // 保存原始响应
                String scrapingPath = FileConstant.FILE_SAVE_DIR + "/scraping/" + sessionId + "_scraping_raw.json";
                cn.hutool.core.io.FileUtil.mkdir(FileConstant.FILE_SAVE_DIR + "/scraping/");
                cn.hutool.core.io.FileUtil.writeString(result, scrapingPath, "UTF-8");

                return WebScrapingResultVO.builder()
                        .status("error")
                        .message("网页抓取请求已提交，但响应格式不符合预期，已保存原始响应")
                        .targetUrl(content)
                        .sessionId(sessionId)
                        .filePath(scrapingPath)
                        .scrapeTime(new Date())
                        .build();
            }
        } catch (Exception e) {
            log.error("网页抓取失败", e);

            return WebScrapingResultVO.builder()
                    .status("error")
                    .message("网页抓取失败：" + e.getMessage())
                    .targetUrl(content)
                    .sessionId(sessionId)
                    .scrapeTime(new Date())
                    .build();
        }
    }

    /**
     * 轮询获取网页抓取结果
     */
    private WebScrapingResultVO pollForWebScrapingResult(String conversationId, String botId, String apiKey,
                                                   String chatId, String searchContent, String sessionId) {
        // 构造API地址
        String checkStatusUrl = "https://api.coze.cn/v3/chat/message/list?" +
                "chat_id=" + chatId +
                "&conversation_id=" + conversationId;

        // 请求头配置
        HashMap<String, String> headers = new HashMap<>();
        headers.put("Authorization", "Bearer " + apiKey);
        headers.put("Content-Type", "application/json");

        // 最多尝试20次，每次间隔3秒
        for (int i = 0; i < 30; i++) {
            try {
                Thread.sleep(6000);
                String result = cn.hutool.http.HttpUtil.createGet(checkStatusUrl)
                        .headerMap(headers, true)
                        .execute()
                        .body();

                cn.hutool.json.JSONObject responseJson = new cn.hutool.json.JSONObject(result);

                // 检查响应状态码
                if (responseJson.getInt("code") == 0 && responseJson.containsKey("data")) {
                    // 获取消息列表
                    cn.hutool.json.JSONArray messages = responseJson.getJSONArray("data");

                    // 遍历消息找到assistant的回复或tool_response
                    for (int j = 0; j < messages.size(); j++) {
                        cn.hutool.json.JSONObject message = messages.getJSONObject(j);
                        String messageType = message.getStr("type");
                        String role = message.getStr("role");
                        
                        if ("assistant".equals(role) && "answer".equals(messageType)) {
                            String content = message.getStr("content");
                            if (cn.hutool.core.util.StrUtil.isNotBlank(content)) {
                                // 找到了搜索结果
                                return processWebScrapingResult(message, searchContent, sessionId);
                            }
                        }
                    }

                    // 如果找不到结果，继续轮询
                    log.info("网页抓取进行中，继续等待... (第{}次尝试)", i + 1);
                } else {
                    log.warn("网页抓取失败，响应异常：{}", result);

                    return WebScrapingResultVO.builder()
                            .status("error")
                            .message("网页抓取失败，请检查响应状态")
                            .targetUrl(searchContent)
                            .sessionId(sessionId)
                            .scrapeTime(new Date())
                            .build();
                }
            } catch (Exception e) {
                log.error("轮询网页抓取状态失败", e);
            }
        }

        return WebScrapingResultVO.builder()
                .status("error")
                .message("网页抓取超时，请稍后重试")
                .targetUrl(searchContent)
                .sessionId(sessionId)
                .scrapeTime(new Date())
                .build();
    }

    /**
     * 处理网页抓取结果
     * @param messageJson 消息JSON对象
     * @param searchContent 搜索内容
     * @param sessionId 会话ID
     * @return 搜索结果
     */
    private WebScrapingResultVO processWebScrapingResult(cn.hutool.json.JSONObject messageJson,
                                                    String searchContent, String sessionId) {
        try {
            // 1. 从消息中提取content字段
            String content = messageJson.getStr("content");
            if (cn.hutool.core.util.StrUtil.isBlank(content)) {
                throw new IllegalArgumentException("消息中缺少content字段");
            }

            // 2. 解析网页内容，提取标题、链接、图片等信息
            String title = extractTitleFromContent(content);
            List<String> links = extractLinksFromContent(content);
            List<String> images = extractImagesFromContent(content);

            // 3. 构建存储路径
            String fileName = sessionId + "_scraping_result.json";
            String saveDir = FileConstant.FILE_SAVE_DIR + "/scraping/";

            // 确保目录存在
            cn.hutool.core.io.FileUtil.mkdir(saveDir);
            String filePath = saveDir + fileName;

            // 4. 创建结构化的抓取结果数据
            cn.hutool.json.JSONObject scrapingData = new cn.hutool.json.JSONObject();
            scrapingData.put("target_url", searchContent);
            scrapingData.put("title", title);
            scrapingData.put("text_content", content);
            scrapingData.put("links", links);
            scrapingData.put("images", images);
            scrapingData.put("session_id", sessionId);
            scrapingData.put("scrape_time", new Date());
            scrapingData.put("raw_message", messageJson);

            // 5. 保存文件
            cn.hutool.core.io.FileUtil.writeUtf8String(scrapingData.toString(), filePath);

            // 6. 构建返回结果
            return WebScrapingResultVO.builder()
                    .status("success")
                    .message("网页抓取完成")
                    .targetUrl(searchContent)
                    .title(title)
                    .textContent(content)
                    .links(links)
                    .images(images)
                    .filePath(filePath)
                    .sessionId(sessionId)
                    .scrapeTime(new Date())
                    .contentLength(content.length())
                    .build();
        } catch (Exception e) {
            // 7. 异常处理
            String errorMessage = "处理网页抓取结果失败";
            if (e instanceof IllegalArgumentException) {
                log.warn("{}：{}", errorMessage, e.getMessage());
                return WebScrapingResultVO.builder()
                        .status("error")
                        .message(errorMessage + "：" + e.getMessage())
                        .targetUrl(searchContent)
                        .sessionId(sessionId)
                        .scrapeTime(new Date())
                        .build();
            } else {
                log.error(errorMessage, e);
                return WebScrapingResultVO.builder()
                        .status("error")
                        .message(errorMessage + "：" + e.getClass().getSimpleName())
                        .targetUrl(searchContent)
                        .sessionId(sessionId)
                        .scrapeTime(new Date())
                        .build();
            }
        }
    }

    /**
     * 从抓取内容中提取标题
     */
    private String extractTitleFromContent(String content) {
        // 简单的标题提取逻辑，可以根据需要改进
        String[] lines = content.split("\n");
        for (String line : lines) {
            line = line.trim();
            if (cn.hutool.core.util.StrUtil.isNotBlank(line) && line.length() < 100) {
                return line;
            }
        }
        return "网页抓取内容";
    }

    /**
     * 从抓取内容中提取链接
     */
    private List<String> extractLinksFromContent(String content) {
        List<String> links = new ArrayList<>();
        // 使用正则表达式匹配URL
        java.util.regex.Pattern urlPattern = java.util.regex.Pattern.compile(
            "https?://[\\w\\-]+(\\.[\\w\\-]+)+([\\w\\-\\.,@?^=%&:/~\\+#]*[\\w\\-\\@?^=%&/~\\+#])?");
        java.util.regex.Matcher matcher = urlPattern.matcher(content);
        
        while (matcher.find() && links.size() < 20) {
            links.add(matcher.group());
        }
        
        return links;
    }

    /**
     * 从抓取内容中提取图片链接
     */
    private List<String> extractImagesFromContent(String content) {
        List<String> images = new ArrayList<>();
        // 使用正则表达式匹配图片URL
        java.util.regex.Pattern imgPattern = java.util.regex.Pattern.compile(
            "https?://[\\w\\-]+(\\.[\\w\\-]+)+([\\w\\-\\.,@?^=%&:/~\\+#]*[\\w\\-\\@?^=%&/~\\+#])?\\.(jpg|jpeg|png|gif|bmp|webp)", 
            java.util.regex.Pattern.CASE_INSENSITIVE);
        java.util.regex.Matcher matcher = imgPattern.matcher(content);
        
        while (matcher.find() && images.size() < 10) {
            images.add(matcher.group());
        }
        
        return images;
    }

    /**
     * 网页抓取（返回JSON字符串）
     * @param content 抓取内容
     * @param userId 用户ID
     * @param sessionId 会话ID
     * @return JSON格式的抓取结果
     */
    public String scrapeWebPage(String content, String userId, String sessionId) {
        try {
            WebScrapingResultVO result = performWebScraping(content, userId, sessionId);
            return cn.hutool.json.JSONUtil.toJsonStr(result);
        } catch (Exception e) {
            log.error("网页抓取转换JSON失败", e);
            
            WebScrapingResultVO errorResult = WebScrapingResultVO.builder()
                    .status("error")
                    .message("网页抓取失败：" + e.getMessage())
                    .targetUrl(content)
                    .sessionId(sessionId)
                    .scrapeTime(new Date())
                    .build();
            
            return cn.hutool.json.JSONUtil.toJsonStr(errorResult);
        }
    }
}
